# cron: 35 8 * * *
# new Env("小米钱包")


Check_Value = '00593836068437818963722389822038'
# 原代码注释:
# 变量说明：
# S_XIAOMI_RM：运行模式（设置1为使用社区变量S_XMSQ，设置2为使用单独钱包变量S_XMQB），下面变量也对应更改
# S_XMSQ_KM 或 S_XMQB_KM：卡密
# S_XMSQ 或 S_XMQB：小米CK
# S_XMSQ_DL 或 S_XMQB_DL：并发数量

'''
本工具仅用于学习 Python 加密与逆向工程技术，供研究和教学用途。
请勿将其用于任何非法用途，包括但不限于： 加密恶意脚本 | 逃避安全审计 | 攻击他人系统 | 商业软件加壳绕过
任何使用本工具所造成的直接或间接后果，包括但不限于法律责任、安全问题、数据损失，均由使用者自行承担，作者不对此承担任何责任。
如果您不同意此免责声明，请立即停止使用并删除本文件。
Create at [2025-10-19 00:26:07]
EncryptTools(1.22) | Developed by Python Vorto加密系统
'''

import os
import sys
import importlib.util
import warnings
import requests

# 抑制警告
warnings.filterwarnings('ignore')

class EncryptedModuleLoader:
    """加密模块加载器"""

    def __init__(self, so_file_id: str):
        self.so_file_id = so_file_id
        self.supported_versions = ["3.10", "3.11", "3.12"]
        self.current_version = f"{sys.version_info.major}.{sys.version_info.minor}"
        self._module = None
        self.download_url = "http://so.vorto.cn/api/download"
    
    def validate_environment(self):
        """验证运行环境"""
        if self.current_version not in self.supported_versions:
            raise RuntimeError(f"不支持的Python版本: {self.current_version}")
        print(f"当前Python版本: {self.current_version} (支持)")

    def get_so_filename(self):
        """获取当前版本对应的SO文件名（Linux/Debian专用）"""
        version_suffix = self.current_version.replace('.', '')
        return f"{self.so_file_id}_{version_suffix}.so"

    def find_local_so_file(self):
        """查找本地SO文件"""
        current_dir = os.path.dirname(os.path.abspath(__file__))
        so_filename = self.get_so_filename()
        so_path = os.path.join(current_dir, so_filename)

        if os.path.exists(so_path):
            return so_path
        return None

    def download_so_file(self):
        """从服务器下载SO文件"""
        try:
            so_filename = self.get_so_filename()
            download_url = f"{self.download_url}/so/{self.so_file_id}/{self.current_version}"

            print(f"正在下载 {so_filename}...")
            response = requests.get(download_url, timeout=30)
            response.raise_for_status()

            # 检查响应内容
            if len(response.content) == 0:
                print("下载的SO文件为空")
                return None

            # 保存到临时文件
            current_dir = os.path.dirname(os.path.abspath(__file__))
            so_path = os.path.join(current_dir, so_filename)

            with open(so_path, 'wb') as f:
                f.write(response.content)

            print(f"下载完成: {so_filename} ({len(response.content)} bytes)")

            # 验证文件完整性
            if not self.verify_so_file(so_path):
                print("SO文件验证失败")
                return None

            return so_path

        except Exception as e:
            print(f"下载SO文件失败: {e}")
            return None

    def verify_so_file(self, so_path):
        """验证SO文件的基本完整性"""
        try:
            if not os.path.exists(so_path):
                return False
            
            # 检查文件大小
            file_size = os.path.getsize(so_path)
            if file_size < 1000:  # SO文件通常应该大于1KB
                return False
            
            # 检查文件头（简单验证）
            with open(so_path, 'rb') as f:
                header = f.read(4)
                # ELF文件头标识
                if header[:4] != b'\x7fELF':
                    return False
            
            return True
        except Exception as e:
            print(f"验证SO文件失败: {e}")
            return False

    def load_module(self):
        """加载加密模块"""
        if self._module is not None:
            return self._module

        try:
            # 验证环境
            self.validate_environment()

            # 查找或下载SO文件
            so_file = self.find_local_so_file()
            if so_file is None:
                so_file = self.download_so_file()

            if so_file is None:
                raise FileNotFoundError(f"无法找到或下载SO文件: {self.get_so_filename()}")

            # 检查SO文件是否可读
            if not os.access(so_file, os.R_OK):
                raise PermissionError(f"无法读取SO文件: {so_file}")

            print(f"正在加载SO文件: {so_file}")

            # 动态加载模块
            spec = importlib.util.spec_from_file_location("encrypted_module", so_file)
            if spec is None or spec.loader is None:
                raise ImportError("无法创建模块规范")

            self._module = importlib.util.module_from_spec(spec)

            # 将模块添加到sys.modules中
            sys.modules["encrypted_module"] = self._module

            # 执行模块 - 添加错误捕获
            try:
                spec.loader.exec_module(self._module)
                print("SO文件加载成功")
                return self._module
            except Exception as exec_error:
                # 如果执行失败，可能是版本不兼容
                print(f"SO文件执行失败: {exec_error}")
                print("可能原因: SO文件与当前Python版本不兼容")
                raise exec_error

        except ImportError as e:
            if "symbol not found" in str(e) or "undefined symbol" in str(e):
                error_msg = f"SO文件与当前Python环境不兼容: {e}"
                print(error_msg)
                print("可能的解决方案:")
                print("1. 确保SO文件是为当前Python版本和平台编译的")
                print("2. 尝试重新生成SO文件")
                print("3. 检查Python版本是否匹配")
                raise RuntimeError(f"所有版本的SO文件都无法加载: {e}")
            else:
                raise
        except Exception as e:
            error_msg = f"加载加密模块失败: {e}"
            print(error_msg)
            print(f"Python版本: {sys.version}")
            print(f"系统信息: {sys.platform}")
            print(f"SO文件路径: {so_file if 'so_file' in locals() else 'None'}")
            raise RuntimeError(error_msg)
    
    def get_function(self, func_name: str):
        """获取模块中的函数"""
        module = self.load_module()
        
        if not hasattr(module, func_name):
            available_attrs = [attr for attr in dir(module) if not attr.startswith('_')]
            raise AttributeError(
                f"模块中未找到函数 '{func_name}'\n"
                f"可用的属性: {available_attrs}"
            )
        
        return getattr(module, func_name)

# 创建全局加载器实例
_loader = EncryptedModuleLoader("be832f56-2d9f-42cf-9b95-4ae7106e16b2")

def main(*args, **kwargs):
    """入口函数"""
    try:
        func = _loader.get_function("main")
        return func(*args, **kwargs)
    except Exception as e:
        print(f"执行入口函数失败: {e}")
        sys.exit(1)

# 提供其他可能的函数访问方式
def get_encrypted_function(func_name: str):
    """获取加密模块中的指定函数"""
    return _loader.get_function(func_name)

def get_encrypted_module():
    """获取完整的加密模块"""
    return _loader.load_module()

# 自动执行入口函数（如果作为主程序运行）
if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n程序被用户中断")
        sys.exit(0)
    except Exception as e:
        print(f"程序执行失败: {e}")
        sys.exit(1)
